require('dotenv').config();
const express = require('express');
const cors = require('cors');
const fs = require('fs');
const path = require('path');
const initSqlJs = require('sql.js');
const authRoutes = require('./routes/auth');
const habitRoutes = require('./routes/habits');
const articlesRoutes = require('./routes/articles');
const adminRoutes = require('./routes/admin');
const { authenticateToken } = require('./routes/admin');
const cookieParser = require('cookie-parser');

const app = express();
const port = process.env.PORT || 3000;
const dbPath = process.env.DB_PATH || path.join(__dirname, 'behabit.db');

// 中间件
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, '../public')));

// API路由
app.use('/api/auth', authRoutes);
app.use('/api/habits', habitRoutes);
app.use('/api/articles', articlesRoutes);
app.use('/api/admin', adminRoutes);

// 管理后台页面路由
app.get('/admin', (req, res) => {
  // 注意：前端通过普通页面链接访问时无法传递token，所以这里不做验证
  // 而是在前端使用fetchWithAuth访问API时进行验证
  res.sendFile(path.join(__dirname, '../public/admin.html'));
});

// 404路由
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, '../public/index.html'));
});

// 初始化数据库
async function initDatabase() {
  try {
    const SQL = await initSqlJs();
    
    // 如果数据库文件存在，则加载它
    let db;
    if (fs.existsSync(dbPath)) {
      const data = fs.readFileSync(dbPath);
      db = new SQL.Database(data);
      console.log('成功加载现有数据库');
      
      // 检查并更新表结构
      try {
        // 检查habits表是否有trigger_data字段
        const hasTrigerData = db.exec("PRAGMA table_info(habits)").length > 0 && 
          db.exec("PRAGMA table_info(habits)")[0].values.some(row => row[1] === 'trigger_data');
        
        if (!hasTrigerData) {
          console.log('添加habits表的trigger_data字段');
          db.exec('ALTER TABLE habits ADD COLUMN trigger_data TEXT');
        }
        
        // 检查habits表是否有created_at字段
        const hasCreatedAt = db.exec("PRAGMA table_info(habits)").length > 0 && 
          db.exec("PRAGMA table_info(habits)")[0].values.some(row => row[1] === 'created_at');
        
        if (!hasCreatedAt) {
          console.log('添加habits表的created_at字段');
          // 修改：SQLite不允许使用非常量默认值添加列，使用简单的TEXT类型
          db.exec('ALTER TABLE habits ADD COLUMN created_at TEXT');
          
          // 然后更新所有现有行，设置为当前时间
          db.exec("UPDATE habits SET created_at = datetime('now') WHERE created_at IS NULL");
        }
        
        // 检查habit_completions表是否存在
        const tableExists = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='habit_completions'").length > 0;
        
        if (!tableExists) {
          console.log('创建habit_completions表');
          db.exec(`
            CREATE TABLE habit_completions (
              id INTEGER PRIMARY KEY AUTOINCREMENT,
              habit_id INTEGER,
              completed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
              FOREIGN KEY(habit_id) REFERENCES habits(id)
            )
          `);
        }
        
        // 检查users表中是否有created_at字段的空值，并设置日期
        const usersWithoutCreatedAt = db.exec(`
          SELECT COUNT(*) FROM users 
          WHERE created_at IS NULL OR created_at = ''
        `);
        
        if (usersWithoutCreatedAt.length > 0 && usersWithoutCreatedAt[0].values[0][0] > 0) {
          console.log('更新用户的created_at字段');
          db.exec("UPDATE users SET created_at = '2024-12-03T00:00:00.000Z' WHERE created_at IS NULL OR created_at = ''");
        }
        
        // 检查users表是否有role字段
        const hasRoleField = db.exec("PRAGMA table_info(users)").length > 0 && 
          db.exec("PRAGMA table_info(users)")[0].values.some(row => row[1] === 'role');
        
        if (!hasRoleField) {
          console.log('添加users表的role字段');
          db.exec('ALTER TABLE users ADD COLUMN role TEXT DEFAULT "user"');
          
          // 将第一个用户设为管理员
          db.exec(`
            UPDATE users SET role = 'admin' 
            WHERE id = (SELECT MIN(id) FROM users)
          `);
        }
        
        // 检查articles表是否存在
        const articlesTableExists = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='articles'").length > 0;
        
        if (!articlesTableExists) {
          console.log('创建articles表');
          db.exec(`
            CREATE TABLE IF NOT EXISTS articles (
              id INTEGER PRIMARY KEY AUTOINCREMENT,
              title TEXT NOT NULL,
              content TEXT NOT NULL,
              author_id INTEGER,
              created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
              updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
              is_pinned INTEGER DEFAULT 0,
              status TEXT DEFAULT 'published',
              cover_image TEXT,
              FOREIGN KEY(author_id) REFERENCES users(id)
            )
          `);
        }
        
        // 检查habit_completions表是否有is_completed字段
        const hasIsCompletedField = db.exec("PRAGMA table_info(habit_completions)").length > 0 && 
          db.exec("PRAGMA table_info(habit_completions)")[0].values.some(row => row[1] === 'is_completed');
        
        if (!hasIsCompletedField) {
          console.log('添加habit_completions表的is_completed字段');
          db.exec('ALTER TABLE habit_completions ADD COLUMN is_completed INTEGER DEFAULT 0');
        }
        
        // 检查habits表是否有is_archived字段
        const hasIsArchivedField = db.exec("PRAGMA table_info(habits)").length > 0 && 
          db.exec("PRAGMA table_info(habits)")[0].values.some(row => row[1] === 'is_archived');
        
        if (!hasIsArchivedField) {
          console.log('添加habits表的is_archived字段');
          db.exec('ALTER TABLE habits ADD COLUMN is_archived INTEGER DEFAULT 0');
        }
        
        // 检查habits表是否有motivation字段
        const hasMotivationField = db.exec("PRAGMA table_info(habits)").length > 0 && 
          db.exec("PRAGMA table_info(habits)")[0].values.some(row => row[1] === 'motivation');
        
        if (!hasMotivationField) {
          console.log('添加habits表的motivation字段');
          db.exec('ALTER TABLE habits ADD COLUMN motivation TEXT');
        }
        
        // 检查articles表中是否有文章，如果没有则添加一篇默认文章
        const hasArticles = db.exec(`SELECT COUNT(*) FROM articles`);
        
        if (hasArticles.length > 0 && hasArticles[0].values[0][0] === 0) {
          console.log('添加默认文章');
          
          const now = new Date().toISOString();
          
          db.exec(`
            INSERT INTO articles (title, content, created_at, updated_at, is_pinned, status) 
            VALUES (
              'BeHabit使用指南', 
              '# BeHabit使用指南\n\n## 什么是BeHabit？\n\nBeHabit是一个基于科学原理的习惯养成应用，帮助您轻松建立和坚持积极的日常习惯。\n\n## 主要功能\n\n1. **添加习惯**：通过"添加习惯"按钮创建您想要培养的习惯\n2. **完成跟踪**：每天标记您完成的习惯\n3. **进度统计**：查看您的连续天数和完成率统计\n4. **动机评估**：了解您当前的动机水平\n5. **成就徽章**：获取坚持的奖励\n\n## 快速开始\n\n1. 点击"添加习惯"按钮\n2. 输入习惯名称、选择难度级别和提醒方式\n3. 完成习惯后点击"标记完成"\n4. 在进度统计区查看您的成就\n\n开始您的习惯养成之旅吧！',
              '${now}',
              '${now}',
              1,
              'published'
            );
          `);
          
          // 保存数据库
          const data = db.export();
          fs.writeFileSync(dbPath, Buffer.from(data));
        }
        
        // 保存数据库更改
        const data = db.export();
        fs.writeFileSync(dbPath, Buffer.from(data));
      } catch (err) {
        console.error('检查表结构时出错:', err);
      }
    } else {
      // 如果数据库文件不存在，则创建一个新的
      db = new SQL.Database();
      console.log('创建新的数据库');

      // 创建数据库表
      db.exec(`
        CREATE TABLE IF NOT EXISTS users (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          email TEXT UNIQUE,
          password_hash TEXT,
          motivation_score INTEGER DEFAULT 5,
          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
          role TEXT DEFAULT 'user'
        );

        CREATE TABLE IF NOT EXISTS habits (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          user_id INTEGER,
          title TEXT,
          difficulty INTEGER CHECK(difficulty BETWEEN 1 AND 5),
          trigger_type TEXT,
          trigger_data TEXT,
          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
          FOREIGN KEY(user_id) REFERENCES users(id)
        );

        CREATE TABLE IF NOT EXISTS habit_completions (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          habit_id INTEGER,
          completed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
          FOREIGN KEY(habit_id) REFERENCES habits(id)
        );
        
        CREATE TABLE IF NOT EXISTS popular_habits (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          title TEXT,
          description TEXT,
          icon TEXT,
          color TEXT,
          difficulty INTEGER CHECK(difficulty BETWEEN 1 AND 5),
          category TEXT,
          popularity INTEGER DEFAULT 0
        );
        
        CREATE TABLE IF NOT EXISTS articles (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          title TEXT NOT NULL,
          content TEXT NOT NULL,
          author_id INTEGER,
          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
          is_pinned INTEGER DEFAULT 0,
          status TEXT DEFAULT 'published',
          cover_image TEXT,
          FOREIGN KEY(author_id) REFERENCES users(id)
        );
        
        CREATE TABLE IF NOT EXISTS settings (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          key TEXT UNIQUE,
          value TEXT,
          description TEXT
        );
        
        CREATE TABLE IF NOT EXISTS roles (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT UNIQUE,
          description TEXT
        );
        
        CREATE TABLE IF NOT EXISTS permissions (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT UNIQUE,
          description TEXT
        );
        
        CREATE TABLE IF NOT EXISTS role_permissions (
          role_id INTEGER,
          permission_id INTEGER,
          PRIMARY KEY (role_id, permission_id),
          FOREIGN KEY(role_id) REFERENCES roles(id),
          FOREIGN KEY(permission_id) REFERENCES permissions(id)
        );
      `);
      
      // 添加一些推荐习惯
      db.exec(`
        INSERT INTO popular_habits (title, description, icon, color, difficulty, category, popularity) VALUES
        ('每天喝8杯水', '保持身体水分，增强新陈代谢', 'glass-water', 'blue', 1, '健康', 100),
        ('10分钟冥想', '放松心情，减轻压力', 'spa', 'green', 2, '心理', 95),
        ('早起5分钟', '利用早晨宝贵时间', 'sun', 'yellow', 2, '生活', 90),
        ('3分钟伸展运动', '唤醒身体，增强灵活性', 'running', 'red', 1, '运动', 85),
        ('阅读10页书', '培养阅读习惯，增长知识', 'book', 'purple', 2, '学习', 80),
        ('写感恩日记', '记录3件感恩的事，培养积极心态', 'pen', 'indigo', 2, '心理', 75),
        ('5个俯卧撑', '增强核心力量，无需器械', 'dumbbell', 'red', 3, '运动', 70),
        ('整理工作区域', '保持环境整洁，提高效率', 'broom', 'brown', 2, '生活', 65),
        ('手机静音1小时', '远离干扰，专注当下', 'mobile-alt', 'gray', 3, '数字健康', 60),
        ('深呼吸3次', '缓解紧张，调整状态', 'wind', 'cyan', 1, '心理', 55)
      `);

      // 添加默认角色和权限
      const rolesExist = db.exec(`SELECT COUNT(*) FROM roles`);
      if (rolesExist.length > 0 && rolesExist[0].values[0][0] === 0) {
        console.log('添加默认角色和权限');
        
        // 添加角色
        db.exec(`
          INSERT INTO roles (name, description) VALUES
          ('admin', '系统管理员，拥有所有权限'),
          ('editor', '内容编辑，可以管理文章和习惯'),
          ('user', '普通用户')
        `);
        
        // 添加权限
        db.exec(`
          INSERT INTO permissions (name, description) VALUES
          ('manage_users', '管理用户账户'),
          ('manage_articles', '管理文章'),
          ('manage_habits', '管理习惯库'),
          ('manage_settings', '管理系统设置'),
          ('view_dashboard', '查看管理仪表盘')
        `);
        
        // 分配权限给角色
        db.exec(`
          -- 管理员拥有所有权限
          INSERT INTO role_permissions (role_id, permission_id)
          SELECT 1, id FROM permissions;
          
          -- 编辑拥有文章和习惯管理权限
          INSERT INTO role_permissions (role_id, permission_id)
          SELECT 2, id FROM permissions WHERE name IN ('manage_articles', 'manage_habits', 'view_dashboard');
        `);
      }

      // 添加系统设置
      const settingsExist = db.exec(`SELECT COUNT(*) FROM settings`);
      if (settingsExist.length > 0 && settingsExist[0].values[0][0] === 0) {
        console.log('添加默认系统设置');
        
        db.exec(`
          INSERT INTO settings (key, value, description) VALUES
          ('habits_per_page', '6', '每页显示的习惯数量'),
          ('site_name', 'BeHabit', '网站名称'),
          ('site_description', '养成好习惯，改变好人生', '网站描述')
        `);
      }

      // 添加一些指导性文章
      const articlesExist = db.exec(`SELECT COUNT(*) FROM articles`);
      if (articlesExist.length > 0 && articlesExist[0].values[0][0] === 0) {
        console.log('添加默认文章');
        
        const now = new Date().toISOString();
        
        db.exec(`
          INSERT INTO articles (title, content, created_at, updated_at, is_pinned, status) VALUES
          ('BeHabit系统介绍 - 让习惯养成更简单', 
          '# BeHabit习惯养成系统
          
          BeHabit是一个基于科学方法的习惯养成应用，旨在帮助用户建立和维持积极的日常习惯。
          
          ## 主要功能
          
          - **习惯追踪**：添加并追踪日常习惯，记录完成情况
          - **进度统计**：直观展示习惯坚持情况和连续完成天数
          - **动机评估**：基于完成情况评估动机水平，并提供相应建议
          - **多样提醒**：支持基于时间、位置和活动的习惯触发提醒
          - **习惯推荐**：根据大众数据推荐适合的习惯模板
          
          ## 科学依据
          
          BeHabit基于行为心理学研究，采用以下核心原则：
          
          1. **微习惯原则**：从极小的行动开始，降低开始门槛
          2. **触发机制**：将新习惯与已有行为或特定情境关联
          3. **即时反馈**：完成习惯后立即提供积极反馈
          4. **数据可视化**：通过图表展示进步，增强成就感
          
          ## 适用人群
          
          - 想要培养健康生活方式的人
          - 学生和专业人士寻求提高效率
          - 任何希望通过小习惯实现大改变的人
          
          开始使用BeHabit，每天进步一点点！', 
          '${now}', '${now}', 1, 'published'),
          
          ('福格行为模型：习惯养成的科学指南', 
          '# 福格行为模型：改变行为的科学框架
          
          ## 什么是福格行为模型？
          
          福格行为模型(Fogg Behavior Model, FBM)是由斯坦福大学行为设计实验室创始人BJ Fogg博士提出的行为改变理论。这一模型解释了人类行为发生的三个关键要素：动机(Motivation)、能力(Ability)和触发器(Trigger)。
          
          ## 模型核心公式
          
          行为 = 动机 × 能力 × 触发器
          
          只有当这三个要素同时存在且达到足够水平时，行为才会发生。
          
          ## 三大要素详解
          
          ### 1. 动机(Motivation)
          
          动机是推动人们行动的内在驱力，包含三大核心驱动力：
          
          - **快感/痛苦**：追求愉悦感，避免痛苦
          - **希望/恐惧**：对好结果的期待，对坏结果的恐惧
          - **社会认同/排斥**：获得社会接纳，避免被排斥
          
          ### 2. 能力(Ability)
          
          能力指完成行为的难易程度，受以下因素影响：
          
          - **时间**：完成行为所需的时间
          - **金钱**：完成行为所需的经济成本
          - **体力**：完成行为所需的体力
          - **脑力**：完成行为所需的思考难度
          - **社会偏差**：行为偏离社会规范的程度
          - **非常规性**：行为与日常习惯的差异程度
          
          降低这些因素可以提高行为发生的可能性。
          
          ### 3. 触发器(Trigger)
          
          触发器是激活行为的信号或提示，分为三种类型：
          
          - **火花型触发器(Spark)**：当能力高但动机低时，需要增强动机的触发器
          - **引导型触发器(Facilitator)**：当动机高但能力低时，需要简化行动的触发器
          - **信号型触发器(Signal)**：当动机和能力都高时，仅需一个简单提醒
          
          ## 在BeHabit中的应用
          
          BeHabit应用基于福格行为模型设计，帮助用户:
          
          1. **找到合适的触发点**：关联新习惯与现有行为
          2. **简化行为**：将大目标分解为微小习惯
          3. **提供动机支持**：通过进度统计和成就系统激励坚持
          4. **个性化提醒**：根据用户情况提供最合适的触发器
          
         通过科学地应用福格行为模型，BeHabit帮助用户更容易地建立和维持积极习惯，实现持久的行为改变。', 
          '${now}', '${now}', 1, 'published'),
          
          ('微习惯理论：从小改变开始的大转变', 
          '# 微习惯理论：小步骤实现大改变
          
          ## 什么是微习惯？
          
          微习惯(Tiny Habits)是指极其小、极其容易完成的积极行为，它们需要的意志力极少，几乎不可能失败。微习惯的概念由斯蒂芬·盖斯(Stephen Guise)在他的著作《微习惯》中首次提出，并由BJ Fogg博士的"微习惯方法"进一步发展。
          
          ## 微习惯的核心原则
          
          ### 1. 足够小，几乎荒谬
          
          微习惯必须小到荒谬的程度，例如：
          - 做一个俯卧撑（而不是30分钟锻炼）
          - 冥想一分钟（而不是20分钟）
          - 写一个句子（而不是1000字）
          
          ### 2. 一致性优先于数量
          
          微习惯的目标是建立一致性和自动化，而不是立即获得显著结果。持续做很小的事情最终会带来巨大变化。
          
          ### 3. 满足即可，超额是奖励
          
          只要完成了最小要求，就算成功。有余力可以做更多，但这是额外奖励，不是必须。
          
          ### 4. 意志力不可靠，系统可靠
          
          微习惯系统不依赖于每天的高度动机或强大意志力，而是依靠习惯的力量和系统的支持。
          
          ## 微习惯的科学依据
          
          微习惯有效的科学原因：
          
          1. **降低行为启动阈值**：较小的行为需要较少的激活能量
          2. **减少认知负担**：简单任务减轻决策疲劳
          3. **建立神经通路**：重复行为形成神经联系，促进自动化
          4. **积极自我认同**：成功完成产生成就感，增强积极自我形象
          
          ## 在BeHabit中实践微习惯
          
          BeHabit应用专为支持微习惯设计：
          
          1. **设定微小目标**：鼓励用户设定极小的习惯目标
          2. **庆祝完成**：每次完成后提供即时肯定反馈
          3. **渐进式发展**：从微小开始，随着习惯形成逐渐扩展
          4. **灵活触发机制**：帮助将微习惯与日常活动关联
          
         通过BeHabit的微习惯系统，你可以实现持久的行为改变，不依赖于短暂的意志力爆发，而是通过系统性、科学性的小步骤实现大改变。
          
          开始你的微习惯之旅，感受小变化带来的大不同！', 
          '${now}', '${now}', 0, 'published')
        `);
      }

      // 保存数据库
      const data = db.export();
      fs.writeFileSync(dbPath, Buffer.from(data));
    }

    // 创建定期保存数据库的函数
    const saveDatabase = () => {
      const data = db.export();
      fs.writeFileSync(dbPath, Buffer.from(data));
      console.log('数据库已保存');
    };

    // 将数据库保存到文件，每5分钟保存一次
    const saveInterval = setInterval(saveDatabase, 5 * 60 * 1000);

    // 应用关闭时保存数据库
    process.on('exit', () => {
      clearInterval(saveInterval);
      saveDatabase();
    });

    // 将数据库对象存储为全局对象，以便在路由中使用
    global.db = db;
    global.saveDatabase = saveDatabase;

    // 设置路由
    app.use('/api/auth', authRoutes);
    app.use('/api/habits', habitRoutes);
    app.use('/api/articles', articlesRoutes);
    app.use('/api/admin', adminRoutes);

    app.get('/', (req, res) => {
      res.sendFile(path.join(__dirname, '../public/index.html'));
    });

    // 管理员获取所有推荐习惯
    app.get('/api/admin/recommendations', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }

        const stmt = db.prepare('SELECT * FROM popular_habits ORDER BY id DESC');
        const recommendations = stmt.all();
        
        res.json(recommendations);
      } catch (error) {
        console.error('获取推荐习惯错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 管理员获取所有习惯列表
    app.get('/api/admin/habits', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }
        
        // 获取所有习惯
        const habitsStmt = db.prepare(`
          SELECT h.*, u.email as user_email 
          FROM habits h
          JOIN users u ON h.user_id = u.id
          ORDER BY h.created_at DESC
        `);
        const habits = habitsStmt.all();
        
        res.json(habits);
      } catch (error) {
        console.error('获取所有习惯列表错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 管理员获取习惯汇总数据
    app.get('/api/admin/habits/summary', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }
        
        // 获取总习惯数
        const totalHabitsStmt = db.prepare('SELECT COUNT(*) as count FROM habits');
        const { count: total_habits } = totalHabitsStmt.get();
        
        // 获取已归档的习惯数
        const archivedHabitsStmt = db.prepare('SELECT COUNT(*) as count FROM habits WHERE is_archived = 1');
        const { count: archived_habits } = archivedHabitsStmt.get();
        
        // 获取习惯分类统计
        const categoriesStmt = db.prepare(`
          SELECT category as name, COUNT(*) as count 
          FROM habits 
          GROUP BY category 
          ORDER BY count DESC 
          LIMIT 5
        `);
        const categories = categoriesStmt.all();
        
        // 获取难度分布
        const difficultiesStmt = db.prepare(`
          SELECT difficulty as level, COUNT(*) as count 
          FROM habits 
          GROUP BY difficulty 
          ORDER BY difficulty
        `);
        const difficulties = difficultiesStmt.all();
        
        // 获取最近创建的习惯
        const recentHabitsStmt = db.prepare(`
          SELECT h.id, h.title, h.created_at, h.is_archived, u.email as user_email
          FROM habits h
          JOIN users u ON h.user_id = u.id
          ORDER BY h.created_at DESC
          LIMIT 10
        `);
        const recent_habits = recentHabitsStmt.all();
        
        res.json({
          total_habits,
          archived_habits,
          categories,
          difficulties,
          recent_habits
        });
      } catch (error) {
        console.error('获取习惯汇总数据错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 管理员添加推荐习惯
    app.post('/api/admin/recommendations', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }
        
        const { title, description, icon, color, difficulty, category } = req.body;
        
        // 验证必填字段
        if (!title || !description || !icon || !color || !difficulty || !category) {
          return res.status(400).json({ error: '所有字段都是必填的' });
        }
        
        const stmt = db.prepare(`
          INSERT INTO popular_habits (title, description, icon, color, difficulty, category) 
          VALUES (?, ?, ?, ?, ?, ?)
        `);
        
        const result = stmt.run(title, description, icon, color, difficulty, category);
        global.saveDatabase();
        
        res.status(201).json({ 
          id: result.lastInsertRowid,
          message: '推荐习惯添加成功' 
        });
      } catch (error) {
        console.error('添加推荐习惯错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 管理员更新推荐习惯
    app.put('/api/admin/recommendations/:id', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }
        
        const { id } = req.params;
        const { title, description, icon, color, difficulty, category } = req.body;
        
        // 验证必填字段
        if (!title || !description || !icon || !color || !difficulty || !category) {
          return res.status(400).json({ error: '所有字段都是必填的' });
        }
        
        try {
          // 先检查是否存在
          const checkStmt = db.prepare('SELECT id FROM popular_habits WHERE id = ?');
          const existingHabit = checkStmt.get(id);
          
          if (!existingHabit) {
            return res.status(404).json({ error: '推荐习惯不存在' });
          }
          
          const stmt = db.prepare(`
            UPDATE popular_habits 
            SET title = ?, description = ?, icon = ?, color = ?, difficulty = ?, category = ?
            WHERE id = ?
          `);
          
          stmt.run(title, description, icon, color, difficulty, category, id);
          global.saveDatabase();
          
          res.json({ message: '推荐习惯更新成功' });
        } catch (error) {
          console.error('更新推荐习惯错误:', error);
          res.status(500).json({ error: '服务器错误' });
        }
      } catch (error) {
        console.error('检查用户权限错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 管理员删除推荐习惯
    app.delete('/api/admin/recommendations/:id', authenticateToken, (req, res) => {
      try {
        // 检查用户权限
        const userResult = global.db.exec(`SELECT role FROM users WHERE id = ${req.userId}`);
        
        if (userResult.length === 0 || userResult[0].values.length === 0) {
          return res.status(404).json({ error: '用户不存在' });
        }
        
        const userRole = userResult[0].values[0][0];
        
        if (userRole !== 'admin') {
          return res.status(403).json({ error: '没有权限' });
        }
        
        const { id } = req.params;
        
        try {
          const stmt = db.prepare('DELETE FROM popular_habits WHERE id = ?');
          const result = stmt.run(id);
          global.saveDatabase();
          
          if (result.changes === 0) {
            return res.status(404).json({ error: '推荐习惯不存在' });
          }
          
          res.json({ message: '推荐习惯删除成功' });
        } catch (error) {
          console.error('删除推荐习惯错误:', error);
          res.status(500).json({ error: '服务器错误' });
        }
      } catch (error) {
        console.error('检查用户权限错误:', error);
        res.status(500).json({ error: '服务器错误' });
      }
    });

    // 启动服务器
    app.listen(port, () => {
      console.log(`服务器运行在 http://localhost:${port}`);
    });
  } catch (err) {
    console.error('初始化数据库错误:', err);
    process.exit(1);
  }
}

// 初始化应用
initDatabase(); 